#include "ipc/ipc_common.h"

// 增强版JS执行函数（自动管理上下文）
// cef_v8_value_t *execute_js_function(cef_v8_value_t *func, cef_list_value_t *args) {
//     cef_v8_value_t *ret_value = NULL;
//     cef_v8_context_t *context = NULL;

//     // 获取当前上下文
//     context = cef_v8_context_get_current_context();
//     if (!context || !context->is_valid(context)) {
//         LOG_ERROR("No valid V8 context available");
//         return NULL;
//     }

//     // 进入上下文（必须配对exit）
//     if (!context->enter(context)) {
//         LOG_ERROR("Failed to enter V8 context");
//         return NULL;
//     }

//     // 参数转换和执行
//     const size_t arg_count = args ? args->get_size(args) : 0;
//     cef_v8_value_t **v8_args = NULL;

//     if (arg_count > 0) {
//         v8_args = (cef_v8_value_t **)calloc(arg_count, sizeof(cef_v8_value_t *));
//         for (size_t i = 0; i < arg_count; ++i) {
//             v8_args[i] = convert_cefvalue_to_v8value(args, i);
//             if (!v8_args[i]) {
//                 LOG_ERROR("Failed to convert argument %zu", i);
//                 v8_args[i] = cef_v8_value_create_null();
//             }
//         }
//     }

//     // 执行函数
//     ret_value = func->execute_function(func, NULL, // receiver
//                                        arg_count, v8_args);

//     // 清理参数
//     if (v8_args) {
//         for (size_t i = 0; i < arg_count; ++i) {
//             if (v8_args[i]) {
//                 v8_args[i]->base.release(&v8_args[i]->base);
//             }
//         }
//         free(v8_args);
//     }

//     // 退出上下文（必须与enter配对）
//     context->exit(context);

//     return ret_value;
// }

cef_v8_value_t *execute_js_function_single_arg(cef_v8_value_t *func, cef_v8_value_t *arg) {
    cef_v8_value_t *ret_value = NULL;
    LOG_DEBUG("v8 execute_js_function_single_arg start");

    if (!cef_currently_on(TID_RENDERER)) {
        LOG_ERROR("v8 execute_js_function_single_arg error, no TID_RENDERER");
    }

    // 参数处理（强制单参数）
    const size_t arg_count = 1; // 固定一个参数
    cef_v8_value_t **v8_args = (cef_v8_value_t **)calloc(1, sizeof(cef_v8_value_t *));

    // 处理传入参数
    if (arg) {
        // 确保参数类型合法（仅允许基础类型）
        if (arg->is_bool(arg) || arg->is_int(arg) || arg->is_double(arg) || arg->is_string(arg) ||
            arg->is_array_buffer(arg)) {
            arg->base.add_ref(&arg->base); // 增加引用计数
            v8_args[0] = arg;
            LOG_DEBUG("v8 execute_js_function_single_arg  v8_args[0] = arg");
        } else {
            // 非法类型时强制转为null
            v8_args[0] = cef_v8_value_create_null();
            LOG_WARN("Unsupported argument type, converted to null");
        }
    } else {
        // 无参数时设为undefined
        v8_args[0] = cef_v8_value_create_undefined();
    }

    // 执行函数
    ret_value = func->execute_function(func,
                                       NULL, // receiver（使用默认this）
                                       arg_count, v8_args);

    // 清理参数
    // if (v8_args[0]) {
    //     v8_args[0]->base.release(&v8_args[0]->base); // 释放参数引用
    // }
    // free(v8_args);

    LOG_DEBUG("v8 execute_js_function_single_arg end");

    return ret_value;
}

// cefvalue -> v8value---------------------------------------------------------------

// 释放回调实现
void CEF_CALLBACK release_buffer_wrapper(struct _cef_v8_array_buffer_release_callback_t *self, void *buffer) {
    // 通过结构体偏移获取完整上下文
    BinaryReleaseContext *ctx = (BinaryReleaseContext *)self;
    // 释放数据缓冲区
    if (ctx->copied_buffer) {
        free(ctx->copied_buffer);
        ctx->copied_buffer = NULL;
    }
    // 释放二进制值引用
    if (ctx->binary) {
        ctx->binary->base.release(&ctx->binary->base);
        ctx->binary = NULL;
    }
    // 释放整个上下文结构
    free(ctx);
}

cef_v8_value_t *convert_cefvalue_to_v8value(cef_list_value_t *list, size_t index) {
    if (!list || index >= list->get_size(list)) {
        return cef_v8_value_create_null();
    }

    cef_value_type_t type = list->get_type(list, index);

    switch (type) {
    case VTYPE_NULL:
        return cef_v8_value_create_null();

    case VTYPE_BOOL:
        return cef_v8_value_create_bool(list->get_bool(list, index));

    case VTYPE_INT:
        return cef_v8_value_create_int(list->get_int(list, index));

    case VTYPE_DOUBLE:
        return cef_v8_value_create_double(list->get_double(list, index));

    case VTYPE_STRING: {
        cef_string_userfree_t str = list->get_string(list, index);
        cef_v8_value_t *ret = cef_v8_value_create_string(str);
        cef_string_userfree_free(str);
        return ret;
    }
    case VTYPE_DICTIONARY: {
        cef_dictionary_value_t *dict = list->get_dictionary(list, index);
        return convert_cefdict_to_v8object(dict);
    }
    case VTYPE_LIST: {
        cef_list_value_t *sublist = list->get_list(list, index);
        return convert_ceflist_to_v8array(sublist);
    }
    case VTYPE_BINARY: {
        // 1. 获取二进制值对象
        cef_binary_value_t *binary = list->get_binary(list, index);
        if (!binary)
            return cef_v8_value_create_null();

        // 2. 创建拷贝缓冲区
        const size_t data_size = binary->get_size(binary);
        void *copied_data = malloc(data_size);
        if (!copied_data) {
            binary->base.release(&binary->base);
            return cef_v8_value_create_null();
        }

        // 3. 拷贝数据
        const size_t copied_size = binary->get_data(binary, copied_data, data_size, 0);
        if (copied_size != data_size) {
            free(copied_data);
            binary->base.release(&binary->base);
            return cef_v8_value_create_null();
        }

        // 4. 创建合并的上下文结构
        BinaryReleaseContext *ctx = (BinaryReleaseContext *)malloc(sizeof(BinaryReleaseContext));
        *ctx = (BinaryReleaseContext){.callback = {.base = {sizeof(cef_v8_array_buffer_release_callback_t)},
                                                   .release_buffer = release_buffer_wrapper},
                                      .binary = binary,
                                      .copied_buffer = copied_data};
        // 5. 增加二进制值引用计数
        binary->base.add_ref(&binary->base);

        // 6. 创建ArrayBuffer
        cef_v8_value_t *array_buffer = cef_v8_value_create_array_buffer(copied_data, data_size,
                                                                        &ctx->callback // 传递合并后的回调结构
        );

        // 7. 处理创建失败
        if (!array_buffer) {
            free(copied_data);
            binary->base.release(&binary->base);
            free(ctx);
            return cef_v8_value_create_null();
        }

        return array_buffer;
    }
    case VTYPE_INVALID:
    default:
        return cef_v8_value_create_undefined();
    }
}

// 辅助函数：转换字典到V8对象
cef_v8_value_t *convert_cefdict_to_v8object(cef_dictionary_value_t *dict) {
    if (!dict)
        return cef_v8_value_create_null();

    cef_v8_value_t *obj = cef_v8_value_create_object(NULL, NULL);

    cef_string_list_t keys = cef_string_list_alloc();
    if (dict->get_keys(dict, keys)) {
        const size_t count = cef_string_list_size(keys);
        for (size_t i = 0; i < count; ++i) {
            cef_string_t key;
            if (cef_string_list_value(keys, i, &key)) {
                cef_v8_value_t *value = NULL;
                switch (dict->get_type(dict, &key)) {
                case VTYPE_BOOL:
                    value = cef_v8_value_create_bool(dict->get_bool(dict, &key));
                    break;
                case VTYPE_INT:
                    value = cef_v8_value_create_int(dict->get_int(dict, &key));
                    break;
                case VTYPE_DOUBLE:
                    value = cef_v8_value_create_double(dict->get_double(dict, &key));
                    break;
                case VTYPE_STRING: {
                    cef_string_userfree_t str = dict->get_string(dict, &key);
                    value = cef_v8_value_create_string(str);
                    cef_string_userfree_free(str);
                    break;
                }
                case VTYPE_LIST:
                    value = convert_ceflist_to_v8array(dict->get_list(dict, &key));
                    break;
                case VTYPE_DICTIONARY:
                    value = convert_cefdict_to_v8object(dict->get_dictionary(dict, &key));
                    break;
                default:
                    value = cef_v8_value_create_null();
                }

                if (value) {
                    obj->set_value_bykey(obj, &key, value, V8_PROPERTY_ATTRIBUTE_NONE);
                    value->base.release(&value->base);
                }
                cef_string_clear(&key);
            }
        }
    }
    cef_string_list_free(keys);
    return obj;
}

// 辅助函数：转换列表到V8数组
cef_v8_value_t *convert_ceflist_to_v8array(cef_list_value_t *list) {
    if (!list)
        return cef_v8_value_create_null();

    const size_t length = list->get_size(list);
    cef_v8_value_t *array = cef_v8_value_create_array((int)length);

    for (size_t i = 0; i < length; ++i) {
        cef_v8_value_t *element = convert_cefvalue_to_v8value(list, i);
        if (element) {
            array->set_value_byindex(array, (int)i, element);
            element->base.release(&element->base);
        }
    }
    return array;
}

// v8值转换成cef_list_value_t------------------------------------------------------------------
// 字典转换函数
void convert_v8object_to_cef_dict(cef_v8_value_t *obj, cef_dictionary_value_t *dict) {

    // 获取键列表
    cef_string_list_t keys = cef_string_list_alloc();
    if (!obj->get_keys(obj, keys)) {
        cef_string_list_free(keys);
        return;
    }

    const size_t count = cef_string_list_size(keys);

    for (size_t i = 0; i < count; ++i) {
        cef_string_t key_str;
        if (!cef_string_list_value(keys, i, &key_str)) {
            continue;
        }

        // 获取对应值
        cef_v8_value_t *value = obj->get_value_bykey(obj, &key_str);
        if (!value || !value->is_valid(value)) {
            cef_string_clear(&key_str);
            continue;
        }

        // 保留值引用
        value->base.add_ref(&value->base);

        // 类型处理
        if (value->is_null(value) || value->is_undefined(value)) {
            dict->set_null(dict, &key_str);
        } else if (value->is_bool(value)) {
            dict->set_bool(dict, &key_str, value->get_bool_value(value));
        } else if (value->is_int(value)) {
            dict->set_int(dict, &key_str, value->get_int_value(value));
        } else if (value->is_double(value)) {
            dict->set_double(dict, &key_str, value->get_double_value(value));
        } else if (value->is_string(value)) {
            cef_string_userfree_t str = value->get_string_value(value);
            dict->set_string(dict, &key_str, str);
            cef_string_userfree_free(str);
        } else if (value->is_array(value)) {
            cef_list_value_t *list = convert_v8value_to_cef_list(value);
            if (list) {
                dict->set_list(dict, &key_str, list);
                list->base.release(&list->base);
            }
        } else if (value->is_object(value)) {
            cef_dictionary_value_t *sub_dict = cef_dictionary_value_create();
            sub_dict->base.add_ref(&sub_dict->base);
            convert_v8object_to_cef_dict(value, sub_dict);
            dict->set_dictionary(dict, &key_str, sub_dict);
            sub_dict->base.release(&sub_dict->base);
        } else {
            // 处理其他类型或错误
            dict->set_null(dict, &key_str);
        }

        // 清理资源
        value->base.release(&value->base);
        cef_string_clear(&key_str);
    }

    // 释放键列表
    cef_string_list_free(keys);
}

// 包装函数
cef_dictionary_value_t *convert_v8object_to_dict(cef_v8_value_t *obj) {
    if (!obj || !obj->is_object(obj))
        return NULL;

    cef_dictionary_value_t *dict = cef_dictionary_value_create();
    dict->base.add_ref(&dict->base);

    convert_v8object_to_cef_dict(obj, dict);

    return dict;
}

// 递归转换V8值到CEF列表
cef_list_value_t *convert_v8value_to_cef_list(cef_v8_value_t *v8value) {
    if (!v8value)
        return NULL;

    // 创建新列表并保留引用
    cef_list_value_t *list = cef_list_value_create();
    list->base.add_ref(&list->base);

    // 处理数组类型
    if (v8value->is_array(v8value)) {
        const size_t length = v8value->get_array_length(v8value);
        list->set_size(list, length);

        for (size_t i = 0; i < length; ++i) {
            cef_v8_value_t *element = v8value->get_value_byindex(v8value, i);
            element->base.add_ref(&element->base); // 保留元素引用

            if (element->is_undefined(element) || element->is_null(element)) {
                list->set_null(list, i);
            } else if (element->is_bool(element)) {
                list->set_bool(list, i, element->get_bool_value(element));
            } else if (element->is_int(element)) {
                list->set_int(list, i, element->get_int_value(element));
            } else if (element->is_double(element)) {
                list->set_double(list, i, element->get_double_value(element));
            } else if (element->is_string(element)) {
                cef_string_userfree_t str = element->get_string_value(element);
                list->set_string(list, i, str);
                cef_string_userfree_free(str);
            } else if (element->is_array(element)) {
                cef_list_value_t *sublist = convert_v8value_to_cef_list(element);
                if (sublist) {
                    list->set_list(list, i, sublist);
                    sublist->base.release(&sublist->base);
                }
            } else if (element->is_object(element)) {
                // 处理对象转换为字典（需要额外实现）
                cef_dictionary_value_t *dict = cef_dictionary_value_create();
                dict->base.add_ref(&dict->base);
                convert_v8object_to_cef_dict(element, dict);
                dict->base.release(&dict->base);
            }

            element->base.release(&element->base); // 释放元素引用
        }
    }
    // 处理单个值（非数组）
    else {
        list->set_size(list, 1);
        if (v8value->is_bool(v8value)) {
            list->set_bool(list, 0, v8value->get_bool_value(v8value));
        } else if (v8value->is_int(v8value)) {
            list->set_int(list, 0, v8value->get_int_value(v8value));
        } else if (v8value->is_double(v8value)) {
            list->set_double(list, 0, v8value->get_double_value(v8value));
        } else if (v8value->is_string(v8value)) {
            cef_string_userfree_t str = v8value->get_string_value(v8value);
            list->set_string(list, 0, str);
            cef_string_userfree_free(str);
        } else {
            // 不支持的类型设为null
            list->set_null(list, 0);
        }
    }

    return list;
}

// 将 cef_v8_value_t 转换为 cef_value_t（仅处理基础类型）
cef_value_t *ConvertV8ValueToCefValue(cef_v8_value_t *v8_value) {
    if (!v8_value)
        return NULL;

    cef_value_t *cef_val = cef_value_create();

    // 明确类型判断顺序（按优先级）
    if (v8_value->is_bool(v8_value)) {
        cef_val->set_bool(cef_val, v8_value->get_bool_value(v8_value));
    } else if (v8_value->is_int(v8_value)) {
        cef_val->set_int(cef_val, v8_value->get_int_value(v8_value));
    } else if (v8_value->is_double(v8_value)) {
        cef_val->set_double(cef_val, v8_value->get_double_value(v8_value));
    } else if (v8_value->is_string(v8_value)) {
        // 安全提取字符串（避免悬空指针）
        cef_string_t str = {};
        cef_string_userfree_t src = v8_value->get_string_value(v8_value);
        cef_string_copy(src->str, src->length, &str);
        cef_val->set_string(cef_val, &str);
        cef_string_clear(&str);
        cef_string_userfree_free(src);
    } else {
        LOG_INFO("cef_v8value type to cef_value type error");
        cef_val->base.release(&cef_val->base);
        return NULL;
    }
    LOG_DEBUG("cef_v8value type to cef_value type end");
    return cef_val;
}

void CEF_CALLBACK release_buffer(struct _cef_v8_array_buffer_release_callback_t *self, void *buffer) {
    LOG_DEBUG("release_buffer");
    free(buffer);
    free(self);
}

cef_v8_value_t *ConvertCefValueToV8Value(cef_value_t *cef_val) {
    if (!cef_val)
        return NULL;

    cef_v8_value_t *v8_value = NULL;
    const cef_value_type_t type = cef_val->get_type(cef_val);

    switch (type) {
    case VTYPE_BOOL: {
        const int bool_val = cef_val->get_bool(cef_val);
        v8_value = cef_v8_value_create_bool(bool_val);
        break;
    }
    case VTYPE_INT: {
        const int int_val = cef_val->get_int(cef_val);
        v8_value = cef_v8_value_create_int(int_val);
        break;
    }
    case VTYPE_DOUBLE: {
        const double double_val = cef_val->get_double(cef_val);
        v8_value = cef_v8_value_create_double(double_val);
        break;
    }
    case VTYPE_STRING: {
        cef_string_t str = {};
        cef_string_userfree_t src = cef_val->get_string(cef_val);
        cef_string_copy(src->str, src->length, &str);
        v8_value = cef_v8_value_create_string(&str);
        cef_string_clear(&str); // 清理临时字符串内存
        cef_string_userfree_free(src);
        break;
    }
    case VTYPE_NULL:
        v8_value = cef_v8_value_create_null();
        break;
    case VTYPE_BINARY: {
        cef_binary_value_t *binary_value = cef_val->get_binary(cef_val);
        const size_t size = binary_value->get_size(binary_value);
        // const void *data = binary_value->get_raw_data(binary_value);
        // v8_value = cef_v8_value_create_array_buffer_with_copy((void *)data, size);
        // LOG_DEBUG("cef_v8value type to cef_value type end");
        // break;

        void *temp_data = malloc(size);
        if (temp_data) {
            const size_t bytes_read = binary_value->get_data(binary_value, temp_data, size, 0);
            if (bytes_read == size) {
                if (cef_currently_on(TID_RENDERER)) {
                    // 使用不复制的版本，需要确保 temp_data 在 ArrayBuffer 使用期间不被释放
                    v8_value = cef_v8_value_create_array_buffer_with_copy(temp_data, size);
                    LOG_DEBUG("cef_v8value type to cef_value type end");
                } else {
                    LOG_ERROR("Cannot create ArrayBuffer on non-renderer thread");
                }
            }
        }

        if (!v8_value) {
            LOG_ERROR("Failed to create ArrayBuffer from binary data");
            v8_value = cef_v8_value_create_undefined();
        }
        LOG_DEBUG("cef_v8value type to cef_value type end");
        break;
    }
    case VTYPE_LIST:
    case VTYPE_DICTIONARY:
    default: {
        // 记录不支持的类型
        LOG_WARN("Unsupported cef_value type (%d), returning undefined", type);
        v8_value = cef_v8_value_create_undefined();
        break;
    }
    }
    return v8_value;
}

// 类型转化，多参数版本--------------------------------------------------------------------------
// 将 cef_v8_value_t 转换为 cef_list_value_t（仅处理基础类型）
cef_list_value_t *convert_v8_value_to_cef_list_value(cef_v8_value_t *v8_value) {
    if (!v8_value)
        return NULL;

    cef_list_value_t *list = cef_list_value_create();

    // 处理基础类型（bool/int/double/string）
    if (v8_value->is_bool(v8_value)) {
        list->set_size(list, 1);
        list->set_bool(list, 0, v8_value->get_bool_value(v8_value));
    } else if (v8_value->is_int(v8_value)) {
        list->set_size(list, 1);
        list->set_int(list, 0, v8_value->get_int_value(v8_value));
    } else if (v8_value->is_double(v8_value)) {
        list->set_size(list, 1);
        list->set_double(list, 0, v8_value->get_double_value(v8_value));
    } else if (v8_value->is_string(v8_value)) {
        list->set_size(list, 1);
        cef_string_t str = {};
        cef_string_userfree_t src = v8_value->get_string_value(v8_value);
        if (src) {
            cef_string_copy(src->str, src->length, &str);
            list->set_string(list, 0, &str);
            cef_string_clear(&str);
            cef_string_userfree_free(src);
        } else {
            // 字符串获取失败时设置为空字符串
            cef_string_t empty = {};
            list->set_string(list, 0, &empty);
        }
    }
    // 处理一维数组（不处理嵌套）
    else if (v8_value->is_array(v8_value)) {
        int length = v8_value->get_array_length(v8_value);
        list->set_size(list, length);

        for (int i = 0; i < length; ++i) {
            cef_v8_value_t *element = v8_value->get_value_byindex(v8_value, i);
            if (!element) {
                list->set_null(list, i); // 无效元素设为null
                continue;
            }

            // 只处理基础类型，不处理嵌套数组
            if (element->is_bool(element)) {
                list->set_bool(list, i, element->get_bool_value(element));
            } else if (element->is_int(element)) {
                list->set_int(list, i, element->get_int_value(element));
            } else if (element->is_double(element)) {
                list->set_double(list, i, element->get_double_value(element));
            } else if (element->is_string(element)) {
                cef_string_t str = {};
                cef_string_userfree_t src = element->get_string_value(element);
                if (src) {
                    cef_string_copy(src->str, src->length, &str);
                    list->set_string(list, i, &str);
                    cef_string_clear(&str);
                    cef_string_userfree_free(src);
                } else {
                    // 字符串获取失败设为空字符串
                    cef_string_t empty = {};
                    list->set_string(list, i, &empty);
                }
            } else {
                // 非基础类型（包括嵌套数组）设为null
                list->set_null(list, i);
                LOG_DEBUG("Array element type not supported at index: %d", i);
            }

            // 释放元素引用
            element->base.release(&element->base);
        }
    }
    // 处理未支持的类型
    else {
        LOG_INFO("Unsupported cef_v8value type ");
        list->base.release(&list->base);
        return NULL;
    }

    return list;
}

cef_v8_value_t *convert_cef_list_value_to_v8_value(cef_list_value_t *list_value, cef_frame_t *frame) {
    if (!list_value)
        return NULL;

    int size = list_value->get_size(list_value);

    // 处理空列表
    if (size == 0) {
        return cef_v8_value_create_array(0);
    }

    // 处理单元素列表（直接返回基础值）
    if (size == 1) {
        cef_value_type_t type = list_value->get_type(list_value, 0);
        switch (type) {
        case VTYPE_BOOL:
            return cef_v8_value_create_bool(list_value->get_bool(list_value, 0));
        case VTYPE_INT:
            return cef_v8_value_create_int(list_value->get_int(list_value, 0));
        case VTYPE_DOUBLE:
            return cef_v8_value_create_double(list_value->get_double(list_value, 0));
        case VTYPE_STRING: {
            cef_string_userfree_t str = list_value->get_string(list_value, 0);
            cef_v8_value_t *v8_str = cef_v8_value_create_string(str);
            cef_string_userfree_free(str);
            return v8_str;
        }
        case VTYPE_BINARY: {
            cef_v8_context_t *context = frame->get_v8_context(frame);
            if (!context || !context->is_valid(context)) {
                LOG_ERROR("No valid V8 context available");
                return 0;
            }
            context->enter(context); // 进入V8, 否则 cef_v8_value_create_array_buffer_with_copy 不成功
            cef_binary_value_t *binary_value = list_value->get_binary(list_value, 0);
            const size_t size = binary_value->get_size(binary_value);
            void *temp_data = malloc(size);
            if (temp_data) {
                const size_t bytes_read = binary_value->get_data(binary_value, temp_data, size, 0);
                if (bytes_read == size) {
                    if (cef_currently_on(TID_RENDERER)) {
                        // 使用不复制的版本，需要确保 temp_data 在 ArrayBuffer 使用期间不被释放
                        cef_v8_value_t *v8_value = cef_v8_value_create_array_buffer_with_copy(temp_data, size);
                        if (v8_value) {
                            return v8_value;
                        } else {
                            LOG_ERROR("Failed to create ArrayBuffer from binary data");
                            return cef_v8_value_create_undefined();
                        }
                    } else {
                        LOG_ERROR("Cannot create ArrayBuffer on non-renderer thread");
                    }
                }
            }
            break;
        }
        default:
            return cef_v8_value_create_undefined();
        }
    }

    cef_v8_context_t *context = frame->get_v8_context(frame);
    if (!context || !context->is_valid(context)) {
        LOG_ERROR("No valid V8 context available");
        return 0;
    }
    context->enter(context); // 进入V8, 否则 cef_v8_value_create_array_buffer_with_copy cef_v8_value_create_array不成功

    // 处理多元素列表（创建数组）
    cef_v8_value_t *v8_array = cef_v8_value_create_array(size);
    if (!v8_array)
        return NULL;

    for (int i = 0; i < size; i++) {
        cef_value_type_t type = list_value->get_type(list_value, i);
        cef_v8_value_t *element = NULL;

        LOG_DEBUG("list_value[%d] type: %d", i, type);

        switch (type) {
        case VTYPE_BOOL:
            element = cef_v8_value_create_bool(list_value->get_bool(list_value, i));
            break;
        case VTYPE_INT:
            element = cef_v8_value_create_int(list_value->get_int(list_value, i));
            break;
        case VTYPE_DOUBLE:
            element = cef_v8_value_create_double(list_value->get_double(list_value, i));
            break;
        case VTYPE_STRING: {
            cef_string_userfree_t str = list_value->get_string(list_value, i);
            element = cef_v8_value_create_string(str);
            cef_string_userfree_free(str);
            break;
        }
        case VTYPE_BINARY: {
            cef_binary_value_t *binary_value = list_value->get_binary(list_value, i);
            const size_t size = binary_value->get_size(binary_value);
            void *temp_data = malloc(size);
            if (temp_data) {
                const size_t bytes_read = binary_value->get_data(binary_value, temp_data, size, 0);
                if (bytes_read == size) {
                    if (cef_currently_on(TID_RENDERER)) {
                        // 使用不复制的版本，需要确保 temp_data 在 ArrayBuffer 使用期间不被释放
                        cef_v8_value_t *v8_value = cef_v8_value_create_array_buffer_with_copy(temp_data, size);
                        if (v8_value) {
                            return v8_value;
                        } else {
                            LOG_ERROR("Failed to create ArrayBuffer from binary data");
                            return cef_v8_value_create_undefined();
                        }
                    } else {
                        LOG_ERROR("Cannot create ArrayBuffer on non-renderer thread");
                    }
                }
            }
            break;
        }
        default:
            element = cef_v8_value_create_undefined();
            break;
        }

        if (element) {
            v8_array->set_value_byindex(v8_array, i, element);
            // element->base.release(&element->base);
        }
    }

    return v8_array;
}

cef_v8_value_t *execute_js_function(cef_v8_value_t *func, cef_v8_value_t *arg, cef_frame_t *frame) {
    cef_v8_value_t *ret_value = NULL;
    LOG_DEBUG("v8 execute_js_function start");

    if (!cef_currently_on(TID_RENDERER)) {
        LOG_ERROR("v8 execute_js_function error, no TID_RENDERER");
    }

    cef_v8_context_t *context = frame->get_v8_context(frame);
    if (!context || !context->is_valid(context)) {
        LOG_ERROR("No valid V8 context available");
        return 0;
    }
    context->enter(context);

    size_t arg_count = 0;
    cef_v8_value_t **v8_args = NULL;

    // 处理数组参数（多参数）
    if (arg && arg->is_array(arg)) {
        arg_count = arg->get_array_length(arg);
        v8_args = (cef_v8_value_t **)calloc(arg_count, sizeof(cef_v8_value_t *));

        for (size_t i = 0; i < arg_count; i++) {
            cef_v8_value_t *element = arg->get_value_byindex(arg, i);
            if (element) {
                // 检查元素类型是否合法
                if (element->is_bool(element) || element->is_int(element) || element->is_double(element) ||
                    element->is_string(element) || element->is_array_buffer(element)) {

                    element->base.add_ref(&element->base); // 增加引用计数

                    v8_args[i] = element;
                } else {
                    // 非法类型转为 undefined
                    v8_args[i] = cef_v8_value_create_undefined();
                    LOG_WARN("Unsupported array element type at index %zu, converted to undefined", i);
                }
            } else {
                v8_args[i] = cef_v8_value_create_undefined();
            }
        }
    }
    // 处理单参数
    else {
        arg_count = 1;
        v8_args = (cef_v8_value_t **)calloc(1, sizeof(cef_v8_value_t *));

        if (arg) {
            if (arg->is_bool(arg) || arg->is_int(arg) || arg->is_double(arg) || arg->is_string(arg) ||
                arg->is_array_buffer(arg)) {

                arg->base.add_ref(&arg->base); // 增加引用计数

                v8_args[0] = arg;
            } else {
                v8_args[0] = cef_v8_value_create_undefined();
                LOG_WARN("Unsupported argument type, converted to undefined");
            }
        } else {
            v8_args[0] = cef_v8_value_create_undefined();
        }
    }

    // 执行函数
    ret_value = func->execute_function(func, NULL, arg_count, v8_args);

    // 释放资源
    for (size_t i = 0; i < arg_count; i++) {
        // 只释放我们自己创建的undefined值
        if (v8_args[i] && v8_args[i]->is_undefined(v8_args[i]) &&
            v8_args[i] != arg) { // 确保不是原始参数， 原始参数上级函数释放
            v8_args[i]->base.release(&v8_args[i]->base);
        }
    }
    free(v8_args);

    // 退出上下文
    context->exit(context);
    LOG_DEBUG("v8 execute_js_function end");
    return ret_value;
}